home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / GCC 1.37.1r14 / usr / gcc-1.37.1r14 / non-obj files / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-01  |  19.4 KB  |  707 lines  |  [TEXT/KAHL]
  1. #define ZERO(x) bzero(&x, sizeof(x))
  2. #ifdef INIT_LEX
  3.     ZERO(    lineno                            );                
  4.     ZERO(    ridpointers                        );
  5.     ZERO(    current_declspecs                );
  6.     ZERO(    declspec_stack                    );
  7.     ZERO(    undeclared_variable_notice        );
  8.     ZERO(    yychar                            );
  9.     ZERO(    yylval                            );
  10.     ZERO(    yynerrs                            );
  11.     ZERO(    finput                            );
  12. declspec_stack = 0;
  13. input_file_stack = 0;
  14. bzero(&ridpointers, sizeof ridpointers);
  15. yynerrs = 0;
  16. warn_write_strings = 0;
  17. flag_traditional = 0;
  18. undeclared_variable_notice = 0;
  19. current_declspecs = 0;
  20. long_long_integer_type_node = 0;
  21. finput = 0;
  22. integer_type_node = 0;
  23. char_type_node = 0;
  24. lineno = 0;
  25. input_file_stack_tick = 0;
  26. long_long_unsigned_type_node = 0;
  27. input_filename = 0;
  28. long_double_type_node = 0;
  29. flag_no_asm = 0;
  30. signed_char_type_node = 0;
  31. size_zero_node = 0;
  32. current_function_returns_value = 0;
  33. void_type_node = 0;
  34. bzero(&yylval, sizeof yylval);
  35. end_of_file = 0;
  36. wide_buffer = 0;
  37. max_wide = 0;
  38. token_buffer = 0;
  39. maxtoken = 0;
  40. lastiddecl = 0;
  41. #endif
  42. #ifdef INIT_STUPID
  43. after_insn_hard_regs = 0;
  44. regs_live = 0;
  45. reg_order = 0;
  46. reg_crosses_blocks = 0;
  47. reg_where_born = 0;
  48. reg_where_dead = 0;
  49. last_label_suid = 0;
  50. last_jump_suid = 0;
  51. last_call_suid = 0;
  52. uid_suid = 0;
  53. #endif
  54. #ifdef INIT_COMBINE
  55. bzero(&undobuf, sizeof undobuf);
  56. #endif
  57. #ifdef INIT_PARAMETER
  58. bzero(&thestack, sizeof thestack);
  59. paramob = 0;
  60. #endif
  61. #ifdef INIT_LAYOUT
  62. bzero(&size_table, sizeof size_table);
  63. permanent_type_end = 0;
  64. temporary_type_end = 0;
  65. permanent_type_chain = 0;
  66. immediate_size_expand = 0;
  67. temporary_type_chain = 0;
  68. const0_rtx = 0;
  69.     ZERO(    sizetype                        );                
  70.     ZERO(    size_zero_node                    );
  71.     ZERO(    size_one_node                    );
  72.     ZERO(    immediate_size_expand            );
  73.     ZERO(    permanent_type_chain            );
  74.     ZERO(    temporary_type_chain            );
  75.     ZERO(    permanent_type_end                );
  76.     ZERO(    temporary_type_end                );
  77. #endif
  78. #ifdef INIT_TOPLEV
  79. asm_out_file = 0;
  80. main_input_filename = 0;
  81. flow_time = 0;
  82. final_time = 0;
  83. warningcount = 0;
  84. last_error_function = 0;
  85. need_error_newline = 0;
  86. init_flow();
  87. init_recog2();
  88. init_expr2();
  89. init_decl();
  90. init_parse();
  91. init_combine();
  92. init_emit2();
  93. init_final2();
  94. init_integrate();
  95. init_optabs2();
  96. init_parameter();
  97. init_regclass();
  98. init_reload2();
  99. init_reload1();
  100. init_stmt();
  101. init_stupid();
  102. init_tree2();
  103. init_varasm();
  104. init_layout();
  105. init_out_mac();
  106. bzero(&float_handler, sizeof float_handler);
  107. progname = 0;
  108. asm_file_name = 0;
  109. global_alloc_time = 0;
  110. save_argc = 0;
  111. dump_base_name = 0;
  112. save_argv = 0;
  113. parse_time = 0;
  114.     ZERO(    rtx_equal_function_value_matters    );
  115.     ZERO(    jump_opt_dump                    );
  116.     ZERO(    target_flags                    );
  117.     ZERO(    input_filename                    );
  118.     ZERO(    main_input_filename                );
  119.     ZERO(    input_file_stack                );
  120.     ZERO(    input_file_stack_tick            );
  121.     ZERO(    use_gdb_dbx_extensions            );
  122.     ZERO(    warn_unused                        );
  123.     ZERO(    warn_shadow                        );
  124.     ZERO(    warn_switch                        );
  125.     ZERO(    warn_id_clash                    );
  126.     ZERO(    id_clash_len                    );
  127.     ZERO(    profile_block_flag                );
  128.     ZERO(    flag_signed_char                );
  129.     ZERO(    flag_short_enums                );
  130.     ZERO(    flag_volatile                    );
  131.     ZERO(    flag_inline_functions            );
  132.     ZERO(    flag_keep_inline_functions        );
  133.     ZERO(    flag_shared_data                );
  134.     ZERO(    flag_delayed_branch                );
  135.     ZERO(    dump_base_name                    );
  136.     ZERO(    progname                        );
  137.     ZERO(    save_argc                        );
  138.     ZERO(    save_argv                        );
  139.     ZERO(    asm_file_name                    );
  140.     ZERO(    sym_file_name                    );
  141.     ZERO(    asm_out_file                    );
  142.     ZERO(    rtl_dump_file                    );
  143.     ZERO(    jump_opt_dump_file                );
  144.     ZERO(    cse_dump_file                    );
  145.     ZERO(    loop_dump_file                    );
  146.     ZERO(    flow_dump_file                    );
  147.     ZERO(    combine_dump_file                );
  148.     ZERO(    local_reg_dump_file                );
  149.     ZERO(    global_reg_dump_file            );
  150.     ZERO(    jump2_opt_dump_file                );
  151.     ZERO(    dbr_sched_dump_file                );
  152.     ZERO(    parse_time                        );
  153.     ZERO(    varconst_time                    );
  154.     ZERO(    integration_time                );
  155.     ZERO(    jump_time                        );
  156.     ZERO(    cse_time                        );
  157.     ZERO(    loop_time                        );
  158.     ZERO(    flow_time                        );
  159.     ZERO(    combine_time                    );
  160.     ZERO(    local_alloc_time                );
  161.     ZERO(    global_alloc_time                );
  162.     ZERO(    dbr_sched_time                    );
  163.     ZERO(    final_time                        );
  164.     ZERO(    symout_time                        );
  165.     ZERO(    dump_time                        );
  166.     ZERO(    float_handled                    );
  167.     ZERO(    float_handler                    );
  168. #endif
  169. #ifdef INIT_TREE
  170. tree_code_length[1] = 7;
  171. do_identifier_warnings = 0;
  172. tree_node_counter = 0;
  173. bzero(&hash_table, sizeof hash_table);
  174. maybepermanent_firstobj = 0;
  175. momentary_firstobj = 0;
  176. bzero(&maybepermanent_obstack, sizeof maybepermanent_obstack);
  177. momentary_stack = 0;
  178. temporary_firstobj = 0;
  179. rtl_obstack = 0;
  180. bzero(&type_hash_table, sizeof type_hash_table);
  181. bzero(&momentary_obstack, sizeof momentary_obstack);
  182. expression_obstack = 0;
  183. saveable_obstack = 0;
  184. bzero(&permanent_obstack, sizeof permanent_obstack);
  185. bzero(&temporary_obstack, sizeof temporary_obstack);
  186. current_obstack = 0;
  187. set_identifier_size(7);
  188.     ZERO(    all_types_permanent                );
  189.     ZERO(    permanent_obstack                );
  190.     ZERO(    maybepermanent_obstack            );
  191.     ZERO(    temporary_obstack                );
  192.     ZERO(    momentary_obstack                );
  193.     ZERO(    saveable_obstack                );
  194.     ZERO(    current_obstack                    );
  195.     ZERO(    expression_obstack                );
  196.     ZERO(    maybepermanent_firstobj            );
  197.     ZERO(    temporary_firstobj                );
  198.     ZERO(    momentary_firstobj                );
  199.     ZERO(    momentary_stack                    );
  200.     ZERO(    type_hash_table                    );
  201. #endif
  202. #ifdef INIT_STMT
  203. parm_reg_stack_loc = 0;
  204. max_parm_reg = 0;
  205. last_parm_insn = 0;
  206. last_expr_type = 0;
  207. nesting_stack = 0;
  208. rtl_expr_chain = 0;
  209. last_expr_value = 0;
  210. tail_recursion_reentry = 0;
  211. invalid_stack_slot = 0;
  212. frame_offset = 0;
  213. this_function = 0;
  214. parm_birth_insn = 0;
  215.     ZERO(    current_function_calls_setjmp    );                
  216.     ZERO(    save_expr_regs                    );
  217.     ZERO(    current_function_calls_alloca    );
  218.     ZERO(    current_function_pops_args        );
  219.     ZERO(    current_function_returns_struct    );
  220.     ZERO(    current_function_returns_pcc_struct);
  221.     ZERO(    current_function_needs_context    );
  222.     ZERO(    current_function_returns_pointer    );
  223.     ZERO(    current_function_args_size        );
  224.     ZERO(    current_function_pretend_args_size    );
  225.     ZERO(    current_function_name            );
  226.     ZERO(    current_function_is_pascal        );
  227.     ZERO(    cleanup_label                    );
  228.     ZERO(    return_label                    );
  229.     ZERO(    stack_slot_list                    );
  230.     ZERO(    emit_filename                    );
  231.     ZERO(    emit_lineno                        );
  232.     ZERO(    block_stack                        );
  233.     ZERO(    stack_block_stack                );
  234.     ZERO(    cond_stack                        );
  235.     ZERO(    loop_stack                        );
  236.     ZERO(    case_stack                        );
  237.     ZERO(    nesting_stack                    );
  238.     ZERO(    nesting_depth                    );
  239.     ZERO(    expr_stmts_for_value            );
  240. #endif
  241. #ifdef INIT_OPTABS
  242. bzero(&floattab, sizeof floattab);
  243. bzero(&fixtrunctab, sizeof fixtrunctab);
  244. bzero(&fixtab, sizeof fixtab);
  245. cmp_optab = 0;
  246. sqrt_optab = 0;
  247. sinh_optab = 0;
  248. one_cmpl_optab = 0;
  249. tanh_optab = 0;
  250. log10_optab = 0;
  251. flodiv_optab = 0;
  252. abs_optab = 0;
  253. add_optab = 0;
  254. cos_optab = 0;
  255. exp_optab = 0;
  256. ffs_optab = 0;
  257. ior_optab = 0;
  258. atan_optab = 0;
  259. acos_optab = 0;
  260. asin_optab = 0;
  261. ashr_optab = 0;
  262. ashl_optab = 0;
  263. log_optab = 0;
  264. mov_optab = 0;
  265. cosh_optab = 0;
  266. neg_optab = 0;
  267. smul_widen_optab = 0;
  268. umul_widen_optab = 0;
  269. sin_optab = 0;
  270. sub_optab = 0;
  271. tan_optab = 0;
  272. lshr_optab = 0;
  273. lshl_optab = 0;
  274. xor_optab = 0;
  275. rotr_optab = 0;
  276. rotl_optab = 0;
  277. sdiv_optab = 0;
  278. smod_optab = 0;
  279. smul_optab = 0;
  280. udiv_optab = 0;
  281. umod_optab = 0;
  282. movstrict_optab = 0;
  283. and_optab = 0;
  284. sdivmod_optab = 0;
  285. udivmod_optab = 0;
  286. ucmp_optab = 0;
  287. umul_optab = 0;
  288. ftrunc_optab = 0;
  289. tst_optab = 0;
  290. andcb_optab = 0;
  291. bzero(&setcc_gen_fctn, sizeof setcc_gen_fctn);
  292. bzero(&bcc_gen_fctn, sizeof bcc_gen_fctn);
  293. ldconst0_rtx = 0;
  294. const1_rtx = 0;
  295. struct_value_rtx = 0;
  296. static_chain_rtx = 0;
  297. cc0_rtx = 0;
  298. dconst0_rtx = 0;
  299. fconst0_rtx = 0;
  300.     ZERO(    add_optab                        );                
  301.     ZERO(    sub_optab                        );
  302.     ZERO(    smul_optab                        );
  303.     ZERO(    umul_optab                        );
  304.     ZERO(    smul_widen_optab                );
  305.     ZERO(    umul_widen_optab                );
  306.     ZERO(    sdiv_optab                        );
  307.     ZERO(    sdivmod_optab                    );
  308.     ZERO(    udiv_optab                        );
  309.     ZERO(    udivmod_optab                    );
  310.     ZERO(    smod_optab                        );
  311.     ZERO(    umod_optab                        );
  312.     ZERO(    flodiv_optab                    );
  313.     ZERO(    ftrunc_optab                    );
  314.     ZERO(    and_optab                        );
  315.     ZERO(    andcb_optab                        );
  316.     ZERO(    ior_optab                        );
  317.     ZERO(    xor_optab                        );
  318.     ZERO(    ashl_optab                        );
  319.     ZERO(    ashr_optab                        );
  320.     ZERO(    lshl_optab                        );
  321.     ZERO(    lshr_optab                        );
  322.     ZERO(    rotl_optab                        );
  323.     ZERO(    rotr_optab                        );
  324.     ZERO(    mov_optab                        );
  325.     ZERO(    movstrict_optab                    );
  326.     ZERO(    cmp_optab                        );
  327.     ZERO(    tst_optab                        );
  328.     ZERO(    neg_optab                        );
  329.     ZERO(    abs_optab                        );
  330.     ZERO(    one_cmpl_optab                    );
  331.     ZERO(    ffs_optab                        );
  332.     ZERO(    sin_optab                        );
  333.     ZERO(    cos_optab                        );
  334.     ZERO(    tan_optab                        );
  335.     ZERO(    asin_optab                        );
  336.     ZERO(    acos_optab                        );
  337.     ZERO(    atan_optab                        );
  338.     ZERO(    sinh_optab                        );
  339.     ZERO(    cosh_optab                        );
  340.     ZERO(    tanh_optab                        );
  341.     ZERO(    exp_optab                        );
  342.     ZERO(    log_optab                        );
  343.     ZERO(    log10_optab                        );
  344.     ZERO(    sqrt_optab                        );
  345.     ZERO(    bcc_gen_fctn                    );
  346.     ZERO(    setcc_gen_fctn                    );
  347.     ZERO(    ucmp_optab                        );
  348. #endif
  349. #ifdef INIT_VARASM
  350. bzero(&mnames, sizeof mnames);
  351. implist = 0;
  352. bzero(&const_hash_table, sizeof const_hash_table);
  353. function_defined = 0;
  354. in_section = 0;
  355. mtop = 0;
  356. var_labelno = 0;
  357. const_labelno = 0;
  358. bzero(®_class_subclasses, sizeof reg_class_subclasses);
  359. bzero(®_class_superclasses, sizeof reg_class_superclasses);
  360.     ZERO(    const_labelno                    );                
  361.     ZERO(    var_labelno                        );
  362.     ZERO(    mnames                            );
  363.     ZERO(    mtop                            );
  364. #endif
  365. #ifdef INIT_INTEGRATE
  366. parmdecl_map = 0;
  367. insn_map = 0;
  368. #endif
  369. #ifdef INIT_REGCLASS
  370. preferred_or_nothing = 0;
  371. prefclass = 0;
  372. savings = 0;
  373.     ZERO(    max_parallel                    );
  374.     ZERO(    fixed_regs                        );
  375.     ZERO(    fixed_reg_set                    );
  376.     ZERO(    call_used_regs                    );
  377.     ZERO(    call_used_reg_set                );
  378.     ZERO(    call_fixed_regs                    );
  379.     ZERO(    call_fixed_reg_set                );
  380.     ZERO(    global_regs                        );
  381.     ZERO(    reg_class_size                    );
  382.     ZERO(    reg_class_superclasses            );
  383.     ZERO(    reg_class_subclasses            );
  384.     ZERO(    reg_class_subunion                );
  385.     ZERO(    regno_first_uid                    );
  386.     ZERO(    regno_last_uid                    );
  387. #endif
  388. #ifdef INIT_RELOAD
  389. n_reloads = 0;
  390. bzero(&reload_in, sizeof(reload_in));
  391. bzero(&reload_out, sizeof(reload_out));
  392. bzero(&reload_reg_class, sizeof(reload_reg_class));
  393. bzero(&reload_inmode, sizeof(reload_inmode));
  394. bzero(&reload_outmode, sizeof(reload_outmode));
  395. bzero(&reload_strict_low, sizeof(reload_strict_low));
  396. bzero(&reload_reg_rtx, sizeof(reload_reg_rtx));
  397. bzero(&reload_optional, sizeof(reload_optional));
  398. bzero(&reload_inc, sizeof(reload_inc));
  399. bzero(&reload_in_reg, sizeof(reload_in_reg));
  400. bzero(&reload_nocombine, sizeof(reload_nocombine));
  401. bzero(&reload_needed_for_multiple, sizeof(reload_needed_for_multiple));
  402. bzero(&reload_needed_for, sizeof(reload_needed_for));
  403. bzero(&reload_when_needed, sizeof(reload_when_needed));
  404. bzero(&reload_earlyclobbers, sizeof(reload_earlyclobbers));
  405. n_earlyclobbers = 0;
  406. replace_reloads = 0;
  407. bzero(&replacements, sizeof(replacements));
  408. n_replacements = 0;
  409. n_memlocs = 0;
  410. indirect_ok = 0;
  411. static_reload_reg_p = 0;
  412. subst_reg_equivs_changed = 0;
  413. hard_regs_live_known = 0;
  414. output_reloadnum = 0;
  415. this_insn = 0;
  416. bzero(&memlocs, sizeof(memlocs));
  417.     ZERO(    reg_renumber                    );
  418.     ZERO(    reload_in                        );                
  419.     ZERO(    reload_out                        );
  420.     ZERO(    reload_in_reg                    );
  421.     ZERO(    reload_reg_class                );
  422.     ZERO(    reload_inmode                    );
  423.     ZERO(    reload_outmode                    );
  424.     ZERO(    reload_strict_low                );
  425.     ZERO(    reload_optional                    );
  426.     ZERO(    reload_inc                        );
  427.     ZERO(    reload_needed_for_multiple        );
  428.     ZERO(    reload_needed_for                );
  429.     ZERO(    n_reloads                        );
  430.     ZERO(    reload_reg_rtx                    );
  431.     ZERO(    reload_when_needed                );
  432.     ZERO(    n_earlyclobbers                    );
  433.     ZERO(    reload_earlyclobbers            );
  434.     ZERO(    reload_nocombine                );
  435. #endif
  436. #ifdef INIT_RELOAD1
  437. bzero(®s_explicitly_used, sizeof regs_explicitly_used);
  438. bzero(&potential_reload_regs, sizeof potential_reload_regs);
  439. bzero(&spill_regs, sizeof spill_regs);
  440. bzero(&forbidden_regs, sizeof forbidden_regs);
  441. bzero(&spill_reg_order, sizeof spill_reg_order);
  442. bzero(&spill_reg_store, sizeof spill_reg_store);
  443. bzero(®_is_output_reload, sizeof reg_is_output_reload);
  444. reg_equiv_init = 0;
  445. reg_max_ref_width = 0;
  446.     ZERO(    caller_save_needed                );                
  447.     ZERO(    reg_equiv_constant                );
  448.     ZERO(    reg_equiv_address                );
  449.     ZERO(    reg_equiv_mem                    );
  450.     ZERO(    reload_first_uid                );
  451.     ZERO(    double_reg_address_ok            );
  452.     ZERO(    basic_block_needs                );
  453.     ZERO(    reload_order                    );
  454.     ZERO(    reload_inherited                );
  455.     ZERO(    reload_override_in                );
  456.     ZERO(    reload_spill_index                );
  457. #endif
  458. #ifdef INIT_FINAL
  459. lastfile = 0;
  460. max_block_depth = 0;
  461. pending_blocks = 0;
  462. current_gdbfile = 0;
  463. insn_noperands = 0;
  464. this_is_asm_operands = 0;
  465.     ZERO(    regs_ever_live                    );                
  466.     ZERO(    cc_prev_status                    );
  467.     ZERO(    cc_status                        );
  468.     ZERO(    gdbfiles                        );
  469.     ZERO(    frame_pointer_needed            );
  470.     ZERO(    final_sequence                    );
  471.     ZERO(    next_block_index                );
  472.     ZERO(    profile_label_no                );
  473. #endif
  474. #ifdef INIT_OUT_MAC
  475.     ZERO(    globalize_this                    );
  476.     ZERO(    lbls                            );
  477.     ZERO(    strs                            );
  478. #endif
  479. #ifdef INIT_DECL
  480. global_binding_level = 0;
  481. free_binding_level = 0;
  482. current_binding_level = 0;
  483. obey_regdecls = 0;
  484. long_unsigned_type_node = 0;
  485. float_type_node = 0;
  486. char_array_type_node = 0;
  487. long_integer_type_node = 0;
  488. int_array_type_node = 0;
  489. unsigned_type_node = 0;
  490. double_type_node = 0;
  491. target_flags = 0;
  492. double_ftype_double = 0;
  493. extended_ftype_extended = 0;
  494. current_function_parms = 0;
  495. last_function_parms = 0;
  496. double_ftype_double_double = 0;
  497. long_ftype_long = 0;
  498. warn_cast_qual = 0;
  499. warn_pointer_arith = 0;
  500. flag_signed_char = 0;
  501. warn_unused = 0;
  502. warn_shadow = 0;
  503. sizetype = 0;
  504. int_ftype_int = 0;
  505. short_integer_type_node = 0;
  506. string_type_node = 0;
  507. default_function_type = 0;
  508. integer_zero_node = 0;
  509. value_identifier = 0;
  510. ptr_type_node = 0;
  511. warn_return_type = 0;
  512. int_ftype_ptr_ptr_int = 0;
  513. null_pointer_node = 0;
  514. size_one_node = 0;
  515. current_function_calls_setjmp = 0;
  516. long_double_type_size = 0;
  517. short_unsigned_type_node = 0;
  518. integer_one_node = 0;
  519. void_ftype_ptr_int_int = 0;
  520. void_ftype_ptr_ptr_int = 0;
  521. unsigned_char_type_node = 0;
  522.     ZERO(    long_double_type_size            );
  523.     ZERO(    integer_zero_node                );
  524.     ZERO(    integer_one_node                );
  525.     ZERO(    null_pointer_node                );
  526.     ZERO(    error_mark_node                    );
  527.     ZERO(    void_type_node                    );
  528.     ZERO(    integer_type_node                );
  529.     ZERO(    unsigned_type_node                );
  530.     ZERO(    char_type_node                    );
  531.     ZERO(    current_function_decl            );
  532.     ZERO(    double_type_node                );
  533.     ZERO(    long_double_type_node            );
  534.     ZERO(    float_type_node                    );
  535.     ZERO(    unsigned_char_type_node            );
  536.     ZERO(    signed_char_type_node            );
  537.     ZERO(    short_integer_type_node            );
  538.     ZERO(    short_unsigned_type_node        );
  539.     ZERO(    long_integer_type_node            );
  540.     ZERO(    long_unsigned_type_node            );
  541.     ZERO(    long_long_integer_type_node        );
  542.     ZERO(    long_long_unsigned_type_node    );
  543.     ZERO(    string_type_node                );
  544.     ZERO(    char_array_type_node            );
  545.     ZERO(    int_array_type_node                );
  546.     ZERO(    current_function_returns_value    );
  547.     ZERO(    current_function_returns_null    );
  548.     ZERO(    flag_cond_mismatch                );
  549.     ZERO(    flag_no_asm                        );
  550.     ZERO(    warn_implicit                    );
  551.     ZERO(    warn_return_type                );
  552.     ZERO(    warn_write_strings                );
  553.     ZERO(    warn_pointer_arith                );
  554.     ZERO(    warn_strict_prototypes            );
  555.     ZERO(    warn_cast_qual                    );
  556.     ZERO(    flag_traditional                );
  557.     ZERO(    ptr_type_node                    );
  558.     ZERO(    default_function_type            );
  559.     ZERO(    double_ftype_double                );
  560.     ZERO(    double_ftype_double_double        );
  561.     ZERO(    int_ftype_int                    );
  562.     ZERO(    long_ftype_long                    );
  563.     ZERO(    extended_ftype_extended            );
  564.     ZERO(    void_ftype_ptr_ptr_int            );
  565.     ZERO(    int_ftype_ptr_ptr_int            );
  566.     ZERO(    void_ftype_ptr_int_int            );
  567.     ZERO(    value_identifier                );
  568. #endif
  569. #ifdef INIT_FLOW
  570.     ZERO(    regset_bytes                    );                
  571.     ZERO(    regset_size                        );
  572.     ZERO(    n_basic_blocks                    );
  573.     ZERO(    basic_block_head                );
  574.     ZERO(    basic_block_end                    );
  575.     ZERO(    basic_block_live_at_start        );
  576.     ZERO(    reg_basic_block                    );
  577.     ZERO(    max_regno                        );
  578.     ZERO(    reg_n_refs                        );
  579.     ZERO(    reg_n_sets                        );
  580.     ZERO(    reg_n_deaths                    );
  581.     ZERO(    reg_n_calls_crossed                );
  582.     ZERO(    reg_live_length                    );
  583. #endif
  584. #ifdef INIT_EMIT
  585. no_line_numbers = 0;
  586. first_label_num = 0;
  587. last_insn = 0;
  588. first_insn = 0;
  589. label_num = 1;
  590. cur_insn_uid = 1;
  591. last_linenum = 0;
  592. last_filename = 0;
  593. unshare_copies = 0;
  594.     ZERO(    pc_rtx                            );
  595.     ZERO(    cc0_rtx                            );
  596.     ZERO(    const0_rtx                        );
  597.     ZERO(    const1_rtx                        );
  598.     ZERO(    fconst0_rtx                        );
  599.     ZERO(    dconst0_rtx                        );
  600.     ZERO(    ldconst0_rtx                    );
  601.     ZERO(    stack_pointer_rtx                );
  602.     ZERO(    frame_pointer_rtx                );
  603.     ZERO(    arg_pointer_rtx                    );
  604.     ZERO(    struct_value_rtx                );
  605.     ZERO(    struct_value_incoming_rtx        );
  606.     ZERO(    static_chain_rtx                );
  607.     ZERO(    static_chain_incoming_rtx        );
  608.     ZERO(    regno_pointer_flag                );
  609.     ZERO(    regno_reg_rtx                    );
  610.     ZERO(    cc1_rtx                            );
  611.     ZERO(    regno_pointer_flag_length        );
  612. #endif
  613. #ifdef INIT_RECOG
  614.     ZERO(    volatile_ok                        );                
  615.     ZERO(    recog_addr_dummy                );
  616.     ZERO(    which_alternative                );
  617.     ZERO(    reload_completed                );
  618. #endif
  619. #ifdef INIT_EXPR
  620.     ZERO(    cse_not_expected                );
  621.     ZERO(    inhibit_defer_pop                );
  622.     ZERO(    pending_stack_adjust            );
  623.     ZERO(    may_call_alloca                    );
  624. #endif
  625. #if 0
  626.     ZERO_(    insn_template                    );                
  627.     ZERO_(    insn_outfun                        );
  628.     ZERO_(    insn_gen_function                );
  629.     ZERO_(    insn_n_operands                    );
  630.     ZERO_(    insn_n_dups                        );
  631.     ZERO_(    insn_operand_constraint            );
  632.     ZERO_(    insn_operand_mode                );
  633.     ZERO_(    insn_operand_strict_low            );
  634.     ZERO_(    insn_operand_predicate            );
  635.     ZERO_(    insn_machine_info                );
  636.     ZERO_(    insn_n_alternatives                );
  637.     ZERO_(    reg_class_contents                );                
  638.     ZERO_(    reg_names                        );
  639.     ZERO_(    dollars_in_ident                );                
  640.     ZERO_(    language_string                    );
  641.     ZERO_(    debug_temp_inits                );
  642.     ZERO_(    insn_extract_fn                    );
  643.     ZERO_(    regno_reg_class                    );                
  644.     ZERO_(    obscure_reg_names                );
  645.     ZERO_(    lsix                            );
  646.     ZERO_(    totlen                            );
  647.     ZERO_(    target_switches                    );
  648.     ZERO_(    rtx_name                        );                
  649.     ZERO_(    mode_name                        );
  650.     ZERO_(    mode_class                        );
  651.     ZERO_(    mode_size                        );
  652.     ZERO_(    mode_unit_size                    );
  653.     ZERO_(    mode_wider_mode                    );
  654.     ZERO_(    rtx_format                        );
  655.     ZERO_(    note_insn_name                    );
  656.     ZERO_(    reg_note_name                    );
  657.     ZERO_(    spaces                            );
  658.     ZERO_(    yydebug                            );
  659.     ZERO_(    regs_live_at_setjmp                );
  660.     ZERO_(    reg_rtx_no                        );                
  661.     ZERO_(    sequence_stack                    );
  662.     ZERO_(    push_args_reversed                );                
  663.     ZERO_(    do_preexpand_calls                );
  664.     ZERO_(    rtl_dump                        );                
  665.     ZERO_(    rtl_dump_and_exit                );
  666.     ZERO_(    cse_dump                        );
  667.     ZERO_(    loop_dump                        );
  668.     ZERO_(    flow_dump                        );
  669.     ZERO_(    combine_dump                    );
  670.     ZERO_(    local_reg_dump                    );
  671.     ZERO_(    global_reg_dump                    );
  672.     ZERO_(    jump2_opt_dump                    );
  673.     ZERO_(    dbr_sched_dump                    );
  674.     ZERO_(    write_symbols                    );
  675.     ZERO_(    optimize                        );
  676.     ZERO_(    flag_caller_saves                );
  677.     ZERO_(    flag_pcc_struct_return            );
  678.     ZERO_(    flag_force_mem                    );
  679.     ZERO_(    flag_force_addr                    );
  680.     ZERO_(    flag_defer_pop                    );
  681.     ZERO_(    flag_float_store                );
  682.     ZERO_(    flag_combine_regs                );
  683.     ZERO_(    flag_strength_reduce            );
  684.     ZERO_(    flag_writable_strings            );
  685.     ZERO_(    flag_no_function_cse            );
  686.     ZERO_(    flag_omit_frame_pointer            );
  687.     ZERO_(    flag_no_peephole                );
  688.     ZERO_(    flag_syntax_only                );
  689.     ZERO_(    obey_regdecls                    );
  690.     ZERO_(    quiet_flag                        );
  691.     ZERO_(    inhibit_warnings                );
  692.     ZERO_(    extra_warnings                    );
  693.     ZERO_(    errorcount                        );
  694.     ZERO_(    warningcount                    );
  695.     ZERO_(    sorrycount                        );
  696.     ZERO_(    profile_flag                    );
  697.     ZERO_(    pedantic                        );
  698.     ZERO_(    segment_name                    );
  699.     ZERO_(    generate_trace_calls            );
  700.     ZERO_(    ignore_trace_pragmas            );
  701.     ZERO_(    f_options                        );
  702.     ZERO_(    tree_code_type                    );                
  703.     ZERO_(    tree_code_length                );
  704.     ZERO_(    tree_node_counter                );
  705.     ZERO_(    debug_no_type_hash                );
  706. #endif
  707.